package com.kuang.callable;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

/**
 * Callable实现模板
 *
 */
public class CallableTest {
    public static void main(String[] args) throws Exception {

        //启动callable
        MyThread thread = new MyThread();
        //适配类：FutureTask
        FutureTask futureTask = new FutureTask(thread);
        new Thread(futureTask,"A").start();
        new Thread(futureTask,"B").start();
        /*
            这里两个线程的时候，不会打印2个call
                这里测试过了，实际上不是缓存，是只执行了一次，也就是两个线程后面进入的会覆盖前面的，也有可能是后面进入的被抛弃了，暂时没有更细化的研究
                这个并不是缓存，是由于JVM第二次再调用FutrueTask对象所持有的线程，此时FutrueTask的state此时已非NEW状态（各个状态，这边不做详细解释）


            Possible state transitions:
             NEW -> COMPLETING -> NORMAL
             NEW -> COMPLETING -> EXCEPTIONAL
             NEW -> CANCELLED
             NEW -> INTERRUPTING -> INTERRUPTED

                private volatile int state;
                private static final int NEW          = 0;
                private static final int COMPLETING   = 1;
                private static final int NORMAL       = 2;
                private static final int EXCEPTIONAL  = 3;
                private static final int CANCELLED    = 4;
                private static final int INTERRUPTING = 5;
                private static final int INTERRUPTED  = 6;
         从这些中间状态到最终状态的转换使用更便宜的有序/延迟写入，因为值是唯一的，不能进一步修改。可能的状态转换:新建->完成->正常新建->完成->异常新建->取消新建->中断->中断

         */

        //获取Callable的返回结果
        Integer o = (Integer) futureTask.get();//这个get方法可能会产生阻塞！
        //或者使用异步通信来处理！
        System.out.println(o);
    }
}
class MyThread implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        System.out.println("call");
        //耗时的操作
        return 1024;
    }
}
